home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_200 / 275_02 / prob22.c < prev    next >
Encoding:
C/C++ Source or Header  |  1980-01-01  |  27.4 KB  |  971 lines
  1.  
  2. /* prob22.c                        */
  3. /* program for LCA22 option 't'                */
  4. /* calculate probabilities related to evolution        */
  5. /* Harold V. McIntosh, 10 August 1987            */
  6. /* 29 February 1988 - adapted from LCA21 to LCA22    */
  7.  
  8. /* references:                            */
  9. /*                                */
  10. /* W. John Wilbur, David J. Lipman and Shihab A. Shamma        */
  11. /* On the prediction of local patterns in cellular automata    */
  12. /* Physica 19D 397-410 (1986)                    */ 
  13. /*                                */
  14. /* Howard A. Gutowitz, Jonathan D. Victor and Bruce W. Knight    */
  15. /* Local structure theory for cellular automata            */
  16. /* Physica 28D 18-48 (1987)                    */
  17.  
  18. /*  Copyright (C) 1987  */
  19. /*  Copyright (C) 1988  */
  20. /*  Harold V. McIntosh  */
  21. /*  Gerardo Cisneros S. */
  22.  
  23. # define BROW        3    /* row for bar charts        */
  24. # define EROW        1    /* row for evolution synopsis    */
  25. # define AORG         0    /* x-origin  of contour plot    */
  26. # define BORG       109    /* x-origin  of 2-block param   */
  27. # define CORG       219    /* x-origin  of Bernstein plot  */
  28.  
  29. /* edit the probability screen    */
  30. edtri() {char c;
  31.  
  32.   videomode(COLGRAF);
  33.   videopalette(YELREGR);
  34.  
  35.   while (0<1) {
  36.   videocursor(0,0,0);
  37.   videoputc(':',2);
  38.   scrrul();
  39.   videocursor(0,0,36);
  40.   videoputc('?',2);
  41.   c=kbdin();
  42.   if (c == '\015') break;
  43.   videocursor(0,0,38);
  44.   videoputc(c,2);
  45.   videocursor(0,0,36);
  46.   videoputc(' ',0);
  47.   switch (c) {
  48.     case '+': videopalette(WHCYMAG); break;
  49.     case '-': videopalette(YELREGR); break;
  50.     case 'a': asfreq(3); break;
  51.     case 'e': pevolve(); break;
  52.     case 'g': lifreq(50,2); break;
  53.     case 'G': lifreq(200,1); break;
  54.     case 'm': moncar(1,2); break;
  55.     case 'M': moncar(50,1); break;
  56.     case 'x': pdiff(100); break;
  57.     case 'i': pidiff(100); break;
  58.     case 'j': pjdiff(100); break;
  59.     case 'y': pdiff3(100); break;
  60.     case 'z': pdiff4(100); break;
  61.     case 't': twoblockfreq(100); break;
  62.     case '1': nblclr(); oneblfreq(8*BROW,300,48); break;
  63.     case '2': nblclr(); twoblfreq(8*BROW,300,48); break;
  64.     case '3': nblclr(); thrblfreq(8*BROW,300,48); break;
  65.     case '4': nblclr(); foublfreq(8*BROW,300,48); break;
  66.     case '5': nblclr(); fivblfreq(8*BROW,300,48); break;
  67.     case '6': nblclr(); sixblfreq(8*BROW,300,48); break;
  68.     case '?': videomode(COLGRAF); videopalette(YELREGR); trmenu(); break;
  69.     case '/': videomode(COLGRAF); videopalette(YELREGR); break;
  70.     default: break;
  71.     }; /* end switch */
  72.   };   /* end while  */
  73.   videopalette(WHCYMAG);
  74.   videomode(T80X25);
  75. }      /* end edtri  */
  76.  
  77. /* show menu */
  78. trmenu() {
  79.   videoscroll(BROW,0,BROW+8,40,0,0);
  80.   videocursor(0,BROW,0);
  81.   printf("a       - a priori estimates\n");
  82.   printf("m,M,g,G - sample evolution\n");
  83.   printf("xyz     - selfconsistent probabilities\n");
  84.   printf("xij     - iterated s-c probabilities\n");
  85.   printf("t       - graph 2 block probabilities\n");
  86.   printf("123456  - n-block bar charts\n");
  87.   printf("+-      - change color pallette\n");
  88.   printf("e       - 12 lines evolution\n");
  89.   printf("/?(clear screen, show menu), <cr>(exit)\n");
  90. }
  91.  
  92. /* show twelve lines of evolution at top of screen */
  93. pevolve() {int i, j;
  94.   videoscroll(EROW,0,EROW+1,40,0,0);
  95.   asctobin();
  96.   for (j=8*EROW; j<8*(EROW+2)-3; j++) {
  97.     for (i=0; i<AL; i++) videodot(j,i,arr1[i]);
  98.     onegen(AL);
  99.     };
  100. }
  101.  
  102. /* Clear a space for the n-block frequencies */
  103. nblclr() {videoscroll(BROW,0,BROW+8,40,0,0);}
  104.  
  105. /* make a frame for a graph          */
  106. /* (x,y) = lower left corner; e.g. (0,0) */
  107. /* n     = dimension of frame            */
  108. gfram(x,y,n) int x, y, n; {int i;
  109.  
  110. for (i=0; i<=n; i++) videodot(199-y-i,x,0);
  111. for (i=0; i<=n; i++) videodot(199-y-i,x+n,0);
  112. for (i=0; i<=n; i++) videodot(199-n-y,x+i,0);
  113. for (i=0; i<=n; i++) videodot(199-y,x+i,0);
  114.  
  115. for (i=0; i<=n; i+=10) videodot(199-y-i,x,3);
  116. for (i=0; i<=n; i+=10) videodot(199-y-i,x+n,3);
  117. for (i=0; i<=n; i+=10) videodot(199-n-y,x+i,3);
  118. for (i=0; i<=n; i+=10) videodot(199-y,x+i,3);
  119. }
  120.  
  121. /* put a diagonal in a graph */
  122. gdiag(x,y,n) int x, y, n; {int i;
  123. for (i=0; i<=n; i+=2) videodot(199-y-i,x+i,3);
  124. }
  125.  
  126. /* graph Bernstein polynomial */
  127. bgraf(x,y,k,n) int x, y, k, n; {int i; double bern(), en, dp, p;
  128. if (n==0) return;
  129. en=(double)(n); dp=1.0/en;
  130. for (i=0,p=0.0; i<n; i++,p+=dp) {videodot(199-y-(int)(en*bern(p,k)),x+i,1);};
  131. }
  132.  
  133. /* "Monte Carlo" determination of probabilities */
  134. moncar(n,l) int n, l; {
  135. int i, j, k, b[KK], bb[KK][KK];
  136. double bf[KK], bbf[KK][KK];
  137.  
  138. nblclr();
  139. gfram(BORG,0,100);
  140. asctobin();
  141. for (k=0; k<n; k++) {
  142.   onegen(AL);
  143.   for (i=0; i<KK; i++) b[i]=0;
  144.   for (i=0; i<AL; i++) b[arr1[i]]++;
  145.   for (i=0; i<KK; i++) bf[i]=((double)(b[i]))/((double)(AL));
  146.   for (i=0; i<KK; i++) for (j=0; j<KK; j++) bb[i][j]=0;
  147.   for (i=1; i<AL; i++) bb[arr1[i-1]][arr1[i]]++;
  148.   bb[arr1[AL-1]][arr1[0]]++; 
  149.   for (i=0; i<KK; i++) for (j=0; j<KK; j++) 
  150.     bbf[i][j]=((double)(bb[i][j]))/((double)(AL));
  151.   videodot(199-(int)(100.0*bbf[1][1]),BORG+(int)(100.0*bf[1]),l);
  152.   };
  153.  videocursor(0,BROW+7,0);
  154. printf("(Monte Carlo) "); 
  155. for (i=0; i<KK; i++) printf("%2d:%5.3f ",i,bf[i]);
  156. videocursor(0,BROW+8,0);
  157. for (i=0; i<KK; i++) for (j=0; j<KK; j++) 
  158.   printf("%1d%1d:%5.3f ",i,j,bbf[i][j]);
  159. }
  160.  
  161. /* Generate coefficients of 2nd generation Bernstein Polynomial */
  162. berncoef() {
  163. int i, i0, i1, i2, i3, i4;
  164.  
  165. for (i=0; i<BD; i++) bp[i]=0.0;
  166. for (i0=0; i0<KK; i0++) {
  167. for (i1=0; i1<KK; i1++) {
  168. for (i2=0; i2<KK; i2++) {
  169. for (i3=0; i3<KK; i3++) {
  170. for (i4=0; i4<KK; i4++) {
  171.   if (ascrule[i0][i1][i2][i3][i4]=='1') bp[i0+i1+i2+i3+i4]+=1.0;
  172.   };};};};};
  173. }
  174.  
  175. /* Generate coefficients of 3rd generation Bernstein Polynomial */
  176. bernthrd() {
  177. int i, i0, i1, i2, i3, i4, i5, i6, i7, i8;
  178. int j0, j1, j2, j3, j4;
  179.  
  180. asctobin();
  181. for (i=0; i<BD; i++) bp[i]=0.0;
  182. for (i0=0; i0<KK; i0++) {
  183. for (i1=0; i1<KK; i1++) {
  184. for (i2=0; i2<KK; i2++) {
  185. for (i3=0; i3<KK; i3++) {
  186. for (i4=0; i4<KK; i4++) {
  187. for (i5=0; i5<KK; i5++) {
  188. for (i6=0; i6<KK; i6++) {
  189. for (i7=0; i7<KK; i7++) {
  190. for (i8=0; i8<KK; i8++) {
  191.   j0=binrule[i0][i1][i2][i3][i4];
  192.   j1=binrule[i1][i2][i3][i4][i5];
  193.   j2=binrule[i2][i3][i4][i5][i6];
  194.   j3=binrule[i3][i4][i5][i6][i7];
  195.   j4=binrule[i4][i5][i6][i7][i8];
  196.   if (ascrule[j0][j1][j2][j3][j4]=='1') bp[i0+i1+i2+i3+i4+i5+i6+i7+i8]+=1.0;
  197.   };};};};};};};};};
  198. }
  199.  
  200. /* Generate coefficients of 4th generation Bernstein Polynomial */
  201. bernfrth() {
  202. int i, i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, ia, ib, ic;
  203. int j0, j1, j2, j3, j4, j5, j6, j7, j8;
  204. int k0, k1, k2, k3, k4;
  205.  
  206. asctobin();
  207. for (i=0; i<BD; i++) bp[i]=0.0;
  208. for (i0=0; i0<KK; i0++) {
  209. for (i1=0; i1<KK; i1++) {
  210. for (i2=0; i2<KK; i2++) {
  211. for (i3=0; i3<KK; i3++) {
  212. for (i4=0; i4<KK; i4++) {
  213. for (i5=0; i5<KK; i5++) {
  214. for (i6=0; i6<KK; i6++) {
  215. for (i7=0; i7<KK; i7++) {
  216. for (i8=0; i8<KK; i8++) {
  217. for (i9=0; i9<KK; i9++) {
  218. for (ia=0; ia<KK; ia++) {
  219. for (ib=0; ib<KK; ib++) {
  220. for (ic=0; ic<KK; ic++) {
  221.   j0=binrule[i0][i1][i2][i3][i4];
  222.   j1=binrule[i1][i2][i3][i4][i5];
  223.   j2=binrule[i2][i3][i4][i5][i6];
  224.   j3=binrule[i3][i4][i5][i6][i7];
  225.   j4=binrule[i4][i5][i6][i7][i8];
  226.   j5=binrule[i5][i6][i7][i8][i9];
  227.   j6=binrule[i6][i7][i8][i9][ia];
  228.   j7=binrule[i7][i8][i9][ia][ib];
  229.   j8=binrule[i8][i9][ia][ib][ic];
  230.   k0=binrule[j0][j1][j2][j3][j4];
  231.   k1=binrule[j1][j2][j3][j4][j5];
  232.   k2=binrule[j2][j3][j4][j5][j6];
  233.   k3=binrule[j3][j4][j5][j6][j7];
  234.   k4=binrule[j4][j5][j6][j7][j8];
  235.   i=i0+i1+i2+i3+i4+i5+i6+i7+i8+i9+ia+ib+ic;
  236.   if (ascrule[k0][k1][k2][k3][k4]=='1') bp[i]+=1.0;
  237.   };};};};};};};};};};};};};
  238. }
  239.  
  240. /* evaluate the nth generation Bernstein polynomial at point p */
  241. double bern(p,n) double p; int n; {double q, s, x, r; int i, d;
  242. d=4*n-3;
  243. if (p>0.99) return bp[d];
  244. q=1.0-p; r=p/q; s=0.0; x=1.0;
  245. for (i=0; i<d;  i++) x*=q;
  246. for (i=0; i<=d; i++, x*=r) s+=bp[i]*x;
  247. s*=0.9998;
  248. return(s+0.0001);
  249. }
  250.  
  251. /* graph the probability of the second generation */
  252. pdiff(n) int n; {
  253. berncoef();
  254. gfram(CORG,0,n);
  255. gdiag(CORG,0,n);
  256. bgraf(CORG,0,2,n);
  257. }
  258.  
  259. /* graph the iterated probability of the second generation */
  260. pidiff(n) int n; {int i; double bern(), en, p;
  261. en=1.0/((double)(n));
  262. berncoef();
  263. gdiag(CORG,0,n);
  264. for (i=0; i<=n; i++) {
  265.   p=((double)(i))*en;
  266.   videodot(199-(int)(100.0*bern(bern(p,2),2)),CORG+(int)(100.0*p),3);
  267.   };
  268. }
  269.  
  270. /* graph the twice iterated probability of the second generation */
  271. pjdiff(n) int n; {int i; double bern(), en, p;
  272. en=1.0/((double)(n));
  273. berncoef();
  274. gdiag(CORG,0,n);
  275. for (i=0; i<=n; i++) {
  276.   p=((double)(i))*en;
  277.   videodot(199-(int)(100.0*bern(bern(bern(p,2),2),2)),CORG+(int)(100.0*p),3);
  278.   };
  279. }
  280.  
  281. /* graph the probability of the third generation */
  282. pdiff3(n) int n; {
  283. bernthrd();
  284. gfram(CORG,0,n);
  285. gdiag(CORG,0,n);
  286. bgraf(CORG,0,3,n);
  287. }
  288.  
  289. /* graph the probability of the fourth generation */
  290. pdiff4(n) int n; {
  291. bernfrth();
  292. gfram(CORG,0,n);
  293. gdiag(CORG,0,n);
  294. bgraf(CORG,0,4,n);
  295. }
  296.  
  297. /* display frequencies in ascrule in color l */
  298. asfreq(l) int l; {
  299. int    i, j, i0, i1, i2, i3, i4;
  300. int    stat[KK], stall, stal, stac, star, starr;    /* statistic counts */
  301. double staf[KK], pp;
  302.  
  303. videoscroll(BROW,0,BROW+8,40,0,0);
  304. videocursor(0,BROW,0);
  305. pp=1.0/((double)(KK*KK*KK*KK*KK));
  306. stall=0; stal=0; stac=0; star=0; starr=0;
  307. for (i=0; i<KK; i++) stat[i]=0;
  308. for (i0=0; i0<KK; i0++) {
  309. for (i1=0; i1<KK; i1++) {
  310. for (i2=0; i2<KK; i2++) {
  311. for (i3=0; i3<KK; i3++) {
  312. for (i4=0; i4<KK; i4++) {
  313.   j=ascrule[i0][i1][i2][i3][i4]-'0';
  314.   stat[j]++;
  315.   if(j==i0) starr++;
  316.   if(j==i1) star++;
  317.   if(j==i2) stac++;
  318.   if(j==i3) stal++;
  319.   if(j==i4) stall++;
  320.   };};};};};
  321. for (i=0; i<KK; i++) printf("%2d    - %5.2f\n",i,((double)stat[i])*pp);
  322. printf("\n");
  323. printf("lleft - %5.2f\n",((double)stall)*pp);
  324. printf("left  - %5.2f\n",((double)stal)*pp);
  325. printf("still - %5.2f\n",((double)stac)*pp);
  326. printf("right - %5.2f\n",((double)star)*pp);
  327. printf("rright- %5.2f\n",((double)starr)*pp);
  328. for (i=0; i<KK; i++) staf[i]=((double)stat[i])*pp;
  329. j=199-(int)(100.0*staf[1]);
  330. i=CORG+(int)(100.0*staf[1]);
  331. if (j>=2) videodot(j-2,i,l);
  332. if (i>=2) videodot(j,i-2,l);
  333. videodot(j,i,1);
  334. if (i<=318) videodot(j,i+2,l);
  335. if (j<=198) videodot(j+2,i,l);
  336. }
  337.  
  338. /* display state frequencies in arr1 as a point on probability graph */
  339. /* n = number of points to plot */
  340. /* l = color of plotted point   */
  341. lifreq
  342. (n,l) int n, l; {int     i,  j, os, ns;
  343. double of, nf, s;
  344.  
  345. s=100.0/((double)AL);
  346. asctobin();
  347. for (i=0; i<n; i++) {
  348.   os=0; ns=0;
  349.   for (j=0; j<AL; j++) if (arr1[j]==1) os++;
  350.   onegen(AL);
  351.   for (j=0; j<AL; j++) if (arr1[j]==1) ns++;
  352.   of=(double)os;
  353.   nf=(double)ns;
  354.   videodot(199-(int)(s*nf),CORG+(int)(s*of),l);
  355.   };
  356. }
  357.  
  358. /* evaluate the parameters for two-block probabilities after one generation */
  359. twoblock(z) double *z; {
  360. int    i, i0, i1, i2, i3, i4, i5;
  361. int    j, j0, j1;
  362. double w, x, y, p, q, pp;
  363. double a[KK][KK], b[KK], c[KK][KK];
  364.  
  365. p=z[0]; q=1.0-p; pp=z[1];
  366. a[1][1]=pp; a[1][0]=a[0][1]=p-pp; a[0][0]=1.0-2*p+pp;
  367. b[1]=p; b[0]=q;
  368. for (i=0; i<KK; i++) {for (j=0; j<KK; j++) c[i][j]=0.0;};
  369. for (i0=0; i0<KK; i0++) {
  370. for (i1=0; i1<KK; i1++) {
  371. for (i2=0; i2<KK; i2++) {
  372. for (i3=0; i3<KK; i3++) {
  373. for (i4=0; i4<KK; i4++) {
  374. for (i5=0; i5<KK; i5++) {
  375.   j0=ascrule[i0][i1][i2][i3][i4]-'0';
  376.   j1=ascrule[i1][i2][i3][i4][i5]-'0';
  377.   x=a[i0][i1]*a[i1][i2]*a[i2][i3]*a[i3][i4]*a[i4][i5];
  378.   y=b[i1]*b[i2]*b[i3]*b[i4];
  379.   w=0.0; if (y>0.00001) w=x/y;
  380.   c[j0][j1]+=w;
  381.   };};};};};};
  382. z[0]=c[1][0]+c[1][1]; z[1]=c[1][1];
  383. }
  384.  
  385. /* graph the 2-block parameter differences to find self-consistent values */
  386. /* nxn points                                   */
  387. twoblockfreq(n) int n; {
  388. int i, j, l;
  389. double op[2], np[2], s, t, u, v;
  390.  
  391. gfram(0,0,100);
  392.  
  393. s=1.0/((double)(n));
  394. op[1]=s;
  395. for (i=1; i<n; i++) {
  396.   op[0]=s;
  397.   for (j=1; j<n; j++) {
  398.     np[0]=op[0]; np[1]=op[1]; twoblock(np);
  399.     u=np[0]-op[0]; v=np[1]-op[1];
  400.     t=u*u+v*v;
  401.     if (t<0.0025) l=0; else {
  402.     if (t<0.0675) {if((i+j)%2) l=0; else l=3;} else {
  403.     if (t<0.3906) l=3; else {
  404.     if (t<0.7500) {if((i+j)%2) l=3; else l=2;} else {
  405.     if (t<1.5000) l=2; else {
  406.     if (t<3.0000) {if((i+j)%2) l=2; else l=1;} else {
  407.     if (t<6.0000) l=1; else {
  408.                   if((i+j)%2) l=1; else l=0;
  409.        }}}}}}}
  410.     videodot(199-i,j,l);
  411.     if (kbdst()) {kbdin(); return;};
  412.     op[0]+=s;
  413.     };  /* end for-j */
  414.   op[1]+=s;
  415.   };    /* end for-i */
  416. }
  417.  
  418. /* evaluate the one-block probabilities after one generation */
  419. onebl(x,a) double x[KK], a[KK]; {int i0, i1, i2, i3, i4, j0;
  420.  
  421. for (j0=0; j0<KK; j0++) x[j0]=0.0;
  422.  
  423. for (i0=0; i0<KK; i0++) {
  424. for (i1=0; i1<KK; i1++) {
  425. for (i2=0; i2<KK; i2++) {
  426. for (i3=0; i3<KK; i3++) {
  427. for (i4=0; i4<KK; i4++) {
  428.   j0=ascrule[i0][i1][i2][i3][i4]-'0';
  429.   x[j0]+=a[i0]*a[i1]*a[i2]*a[i3]*a[i4];
  430.   };};};};};
  431. }
  432.  
  433. /* iterate the 1-block parameters to find self-consistent values */
  434. /* graph the iterative steps in bar-chart form             */
  435. /* ll - initial line    */
  436. /* mm - length of line    */
  437. /* nn - number of lines    */
  438. oneblfreq(ll,mm,nn) int ll, mm, nn; {
  439. int    ii, i, l, m, n;
  440. double op[KK], np[KK];
  441. double d, e, f, s;
  442.  
  443. m=0;
  444. f=(double)mm;
  445. s=1.0/((double)(KK));
  446. n=(int)(f*s);
  447. videodot(ll,m++,3);
  448. for (i=0; i<KK; i++) {op[i]=s; for (l=0; l<n; l++) videodot(ll,m++,i);};
  449.  
  450. for (ii=1; ii<=nn; ii++) {
  451.   e=0.0; m=0;
  452.   onebl(np,op);
  453.   videodot(ll+ii,m++,3);
  454.   for (i=0; i<KK; i++) {
  455.     n=(int)(f*np[i]); if (n>0) for (l=0; l<n; l++) videodot(ll+ii,m++,i);
  456.     d=op[i]-np[i];
  457.     e+=d*d;
  458.     op[i]=np[i];
  459.     };
  460.   videodot(ll+ii,m++,3);
  461.   if (op[0]<=0.001) break;
  462.   if (op[1]<=0.001) break;
  463.   if (e<=0.0000001) break;
  464.   if (kbdst()) {kbdin(); break;};
  465.   };
  466. videocursor(0,BROW+7,0);
  467. printf("(1-block) "); 
  468. for (i=0; i<KK; i++) printf("%2d:%5.3f ",i,op[i]);
  469. }
  470.  
  471. /* evaluate the two-block probabilities after one generation */
  472. twobl(x,a) double x[KK][KK], a[KK][KK]; {
  473. int    i0, i1, i2, i3, i4, i5;
  474. int    j0, j1;
  475. double w, b[KK];
  476.  
  477. for (j0=0; j0<KK; j0++) {for (j1=0; j1<KK; j1++) x[j0][j1]=0.0;};
  478.  
  479. for (j0=0; j0<KK; j0++) {b[j0]=0.0; for (j1=0; j1<KK; j1++) b[j0]+=a[j0][j1];};
  480.  
  481. for (i0=0; i0<KK; i0++) {
  482. for (i1=0; i1<KK; i1++) {
  483. for (i2=0; i2<KK; i2++) {
  484. for (i3=0; i3<KK; i3++) {
  485. for (i4=0; i4<KK; i4++) {
  486. for (i5=0; i5<KK; i5++) {
  487.   j0=ascrule[i0][i1][i2][i3][i4]-'0';
  488.   j1=ascrule[i1][i2][i3][i4][i5]-'0';
  489.   w=a[i0][i1]*a[i1][i2]*a[i2][i3]*a[i3][i4]*a[i4][i5];
  490.   if (w!=0.0) w/=b[i1]*b[i2]*b[i3]*b[i4];
  491.   x[j0][j1]+=w;
  492.   };};};};};};
  493. }
  494.  
  495. /* iterate the 2-block parameters to find self-consistent values */
  496. /* graph the iterative steps in bar-chart form             */
  497. /* ll - initial line    */
  498. /* mm - length of line    */
  499. /* nn - number of lines    */
  500. twoblfreq(ll,mm,nn) int ll, mm, nn; {
  501. int    ii, i, j, l, m, n;
  502. double op[KK][KK], np[KK][KK];
  503. double b[KK], d, e, f, s;
  504.  
  505. m=0;
  506. f=(double)mm;
  507. s=1.0/((double)(KK*KK));
  508. n=(int)(f*s);
  509. videodot(ll,m++,3);
  510. for (i=0; i<KK; i++) {
  511. for (j=0; j<KK; j++) {
  512.   op[i][j]=s;
  513.   for (l=0; l<n; l++) videodot(ll,m++,j);
  514.   };};
  515. videodot(ll,m++,3);
  516.  
  517. for (i=0; i<KK; i++) {b[i]=0.0; for (j=0; j<KK; j++) b[i]+=op[i][j];};
  518. videodot(199-(int)(100.0*op[1][1]),(int)(100.0*b[1]),1);
  519.  
  520. for (ii=1; ii<=nn; ii++) {
  521.   e=0.0; m=0;
  522.   twobl(np,op);
  523.   videodot(ll+ii,m++,3);
  524.   for (i=0; i<KK; i++) {
  525.   for (j=0; j<KK; j++) {
  526.     n=(int)(f*np[i][j]);
  527.     if (n>0) for (l=0; l<n; l++) videodot(ll+ii,m++,j);
  528.     d=op[i][j]-np[i][j];
  529.     e+=d<0.0?-d:d;
  530.     op[i][j]=np[i][j];
  531.     };};
  532.   videodot(ll+ii,m++,3);
  533.   for (i=0; i<KK; i++) {b[i]=0.0; for (j=0; j<KK; j++) b[i]+=op[i][j];};
  534.   videodot(199-(int)(100.0*op[1][1]),(int)(100.0*b[1]),2);
  535.   if (e<=0.0001) break;
  536.   if (kbdst()) {kbdin(); break;};
  537.   };
  538. videocursor(0,BROW+7,0);
  539. printf("(2-block) "); 
  540. for (i=0; i<KK; i++) printf("%2d:%5.3f ",i,b[i]);
  541. videocursor(0,BROW+8,0);
  542. for (i=0; i<KK; i++) for (j=0; j<KK; j++) 
  543.         printf("%1d%1d:%5.3f ",i,j,op[i][j]);
  544. videodot(199-(int)(100.0*op[1][1]),(int)(100.0*b[1]),3);
  545. videodot(199-(int)(100.0*op[1][1]),BORG+(int)(100.0*b[1]),1);
  546. }
  547.  
  548. /* evaluate the three-block probabilities after one generation */
  549. thrbl(x,a) double x[KK][KK][KK], a[KK][KK][KK]; {
  550. int    i0, i1, i2, i3, i4, i5, i6;
  551. int    j0, j1, j2;
  552. double w, b[KK][KK];
  553.  
  554. for (j0=0; j0<KK; j0++) {
  555. for (j1=0; j1<KK; j1++) {
  556.   for (j2=0; j2<KK; j2++) x[j0][j1][j2]=0.0;
  557.   b[j0][j1]=0.0;
  558.   for (j2=0; j2<KK; j2++) b[j0][j1]+=a[j0][j1][j2];  
  559.   };};
  560.  
  561. for (i0=0; i0<KK; i0++) {
  562. for (i1=0; i1<KK; i1++) {
  563. for (i2=0; i2<KK; i2++) {
  564. for (i3=0; i3<KK; i3++) {
  565. for (i4=0; i4<KK; i4++) {
  566. for (i5=0; i5<KK; i5++) {
  567. for (i6=0; i6<KK; i6++) {
  568.   j0=ascrule[i0][i1][i2][i3][i4]-'0';
  569.   j1=ascrule[i1][i2][i3][i4][i5]-'0';
  570.   j2=ascrule[i2][i3][i4][i5][i6]-'0';
  571.   w=a[i0][i1][i2]*a[i1][i2][i3]*a[i2][i3][i4]*a[i3][i4][i5]*a[i4][i5][i6];
  572.   if (w!=0.0) w/=b[i1][i2]*b[i2][i3]*b[i3][i4]*b[i4][i5];
  573.   x[j0][j1][j2]+=w;
  574.   };};};};};};};
  575. }
  576.  
  577. /* iterate the 3-block parameters to find self-consistent values */
  578. /* ll - initial line    */
  579. /* mm - length of line    */
  580. /* nn - number of lines    */
  581. thrblfreq(ll,mm,nn) int ll, mm, nn; {
  582. int    ii, i, j, k, l, m, n;
  583. double op[KK][KK][KK], np[KK][KK][KK];
  584. double b[KK], bb[KK][KK], d, e, f, s;
  585.  
  586. m=0;
  587. f=(double)mm;
  588. s=1.0/((double)(KK*KK*KK));
  589. n=(int)(f*s);
  590. videodot(ll,m++,3);
  591. for (i=0; i<KK; i++) {
  592. for (j=0; j<KK; j++) {
  593. for (k=0; k<KK; k++) {
  594.   op[i][j][k]=s;
  595.   for (l=0; l<n; l++) videodot(ll,m++,k);
  596.   };};};
  597. videodot(ll,m++,3);
  598.  
  599. for (ii=1; ii<=nn; ii++) {
  600.   e=0.0; m=0;
  601.   thrbl(np,op);
  602.   videodot(ll+ii,m++,3);
  603.   for (i=0; i<KK; i++) {
  604.   for (j=0; j<KK; j++) {
  605.   for (k=0; k<KK; k++) {
  606.     n=(int)(f*np[i][j][k]);
  607.     if (n>0) for (l=0; l<n; l++) videodot(ll+ii,m++,k);
  608.     d=op[i][j][k]-np[i][j][k];
  609.     e+=d<0.0?-d:d;
  610.     op[i][j][k]=np[i][j][k];
  611.     };};};
  612.   videodot(ll+ii,m++,3);
  613.   if (e<=0.0001) break;
  614.   if (kbdst()) {kbdin(); break;};
  615.   };
  616.  
  617. for (i=0; i<KK; i++) {
  618.   b[i]=0.0;
  619.   for (j=0; j<KK; j++) {
  620.   for (k=0; k<KK; k++) {
  621.     b[i]+=op[i][j][k];
  622.     };}; };
  623. videocursor(0,BROW+7,0);
  624. printf("(3-block) "); 
  625. for (i=0; i<KK; i++) printf("%2d:%5.3f ",i,b[i]);
  626.  
  627. for (i=0; i<KK; i++) {
  628. for (j=0; j<KK; j++) {
  629.   bb[i][j]=0.0;
  630.   for (k=0; k<KK; k++) {
  631.     bb[i][j]+=op[i][j][k];
  632.     };}; };
  633.  
  634. videocursor(0,BROW+8,0);
  635. for (i=0; i<KK; i++) for (j=0; j<KK; j++) 
  636.   printf("%1d%1d:%5.3f ",i,j,bb[i][j]);
  637. videodot(199-(int)(100.0*bb[1][1]),BORG+(int)(100.0*b[1]),2);
  638. }
  639.  
  640. /* evaluate the four-block probabilities after one generation */
  641. foubl(x,a) double x[KK][KK][KK][KK], a[KK][KK][KK][KK]; {
  642. int    i0, i1, i2, i3, i4, i5, i6, i7;
  643. int    j0, j1, j2, j3;
  644. double w, b[KK][KK][KK];
  645.  
  646. for (j0=0; j0<KK; j0++) {
  647. for (j1=0; j1<KK; j1++) {
  648. for (j2=0; j2<KK; j2++) {
  649.   for (j3=0; j3<KK; j3++) x[j0][j1][j2][j3]=0.0;
  650.   b[j0][j1][j2]=0.0;
  651.   for (j3=0; j3<KK; j3++) b[j0][j1][j2]+=a[j0][j1][j2][j3];  
  652.   };};};
  653.  
  654. for (i0=0; i0<KK; i0++) {
  655. for (i1=0; i1<KK; i1++) {
  656. for (i2=0; i2<KK; i2++) {
  657. for (i3=0; i3<KK; i3++) {
  658. for (i4=0; i4<KK; i4++) {
  659. for (i5=0; i5<KK; i5++) {
  660. for (i6=0; i6<KK; i6++) {
  661. for (i7=0; i7<KK; i7++) {
  662.   j0=ascrule[i0][i1][i2][i3][i4]-'0';
  663.   j1=ascrule[i1][i2][i3][i4][i5]-'0';
  664.   j2=ascrule[i2][i3][i4][i5][i6]-'0';
  665.   j3=ascrule[i3][i4][i5][i6][i7]-'0';
  666.   w=a[i0][i1][i2][i3];
  667.   w*=a[i1][i2][i3][i4];
  668.   w*=a[i2][i3][i4][i5];
  669.   w*=a[i3][i4][i5][i6];
  670.   w*=a[i4][i5][i6][i7];
  671.   if (w!=0.0) w/=b[i1][i2][i3]*b[i2][i3][i4]*b[i3][i4][i5]*b[i4][i5][i6];
  672.   x[j0][j1][j2][j3]+=w;
  673.   };};};};};};};};
  674. }
  675.  
  676. /* iterate the 4-block parameters to find self-consistent values */
  677. /* ll - initial line    */
  678. /* mm - length of line    */
  679. /* nn - number of lines    */
  680. foublfreq(ll,mm,nn) int ll, mm, nn; {
  681. int    ii, i0, i1, i2, i3, l, m, n;
  682. double op[KK][KK][KK][KK], np[KK][KK][KK][KK];
  683. double b[KK], bb[KK][KK], d, e, f, s;
  684.  
  685. m=0;
  686. f=(double)mm;
  687. s=1.0/((double)(KK*KK*KK*KK));
  688. n=(int)(f*s);
  689. videodot(ll,m++,3);
  690. for (i0=0; i0<KK; i0++) {
  691. for (i1=0; i1<KK; i1++) {
  692. for (i2=0; i2<KK; i2++) {
  693. for (i3=0; i3<KK; i3++) {
  694.   op[i0][i1][i2][i3]=s;
  695.   for (l=0; l<n; l++) videodot(ll,m++,i3);
  696.   };};};};
  697. videodot(ll,m++,3);
  698.  
  699. for (ii=1; ii<=nn; ii++) {
  700.   e=0.0; m=0;
  701.   foubl(np,op);
  702.   videodot(ll+ii,m++,3);
  703.   for (i0=0; i0<KK; i0++) {
  704.   for (i1=0; i1<KK; i1++) {
  705.   for (i2=0; i2<KK; i2++) {
  706.   for (i3=0; i3<KK; i3++) {
  707.     n=(int)(f*np[i0][i1][i2][i3]);
  708.     if (n>0) for (l=0; l<n; l++) videodot(ll+ii,m++,i3);
  709.     d=op[i0][i1][i2][i3]-np[i0][i1][i2][i3];
  710.     e+=d<0.0?-d:d;
  711.     op[i0][i1][i2][i3]=np[i0][i1][i2][i3];
  712.     };};};};
  713.   videodot(ll+ii,m++,3);
  714.   if (e<=0.0001) break;
  715.   if (kbdst()) {kbdin(); break;};
  716.   };
  717.  
  718. for (i0=0; i0<KK; i0++) {
  719.   b[i0]=0.0;
  720.   for (i1=0; i1<KK; i1++) {
  721.   for (i2=0; i2<KK; i2++) {
  722.   for (i3=0; i3<KK; i3++) {
  723.     b[i0]+=op[i0][i1][i2][i3];
  724.     };};}; };
  725.  
  726. videocursor(0,BROW+7,0);
  727. printf("(4-block) "); 
  728. for (i0=0; i0<KK; i0++) printf("%2d:%5.3f ",i0,b[i0]);
  729.  
  730. for (i0=0; i0<KK; i0++) {
  731. for (i1=0; i1<KK; i1++) {
  732.   bb[i0][i1]=0.0;
  733.   for (i2=0; i2<KK; i2++) {
  734.   for (i3=0; i3<KK; i3++) {
  735.     bb[i0][i1]+=op[i0][i1][i2][i3];
  736.     };}; };};
  737.  
  738. videocursor(0,BROW+8,0);
  739. for (i0=0; i0<KK; i0++) for (i1=0; i1<KK; i1++) 
  740.   printf("%1d%1d:%5.3f ",i0,i1,bb[i0][i1]);
  741. videodot(199-(int)(100.0*bb[1][1]),BORG+(int)(100.0*b[1]),2);
  742. }
  743.  
  744. /* evaluate the five-block probabilities after one generation */
  745. fivbl(x,a) double x[KK][KK][KK][KK][KK], a[KK][KK][KK][KK][KK]; {
  746. int    i0, i1, i2, i3, i4, i5, i6, i7, i8;
  747. int    j0, j1, j2, j3, j4;
  748. double w, b[KK][KK][KK][KK];
  749.  
  750. for (j0=0; j0<KK; j0++) {
  751. for (j1=0; j1<KK; j1++) {
  752. for (j2=0; j2<KK; j2++) {
  753. for (j3=0; j3<KK; j3++) {
  754.   for (j4=0; j4<KK; j4++) x[j0][j1][j2][j3][j4]=0.0;
  755.   b[j0][j1][j2][j3]=0.0;
  756.   for (j4=0; j4<KK; j4++) b[j0][j1][j2][j3]+=a[j0][j1][j2][j3][j4];  
  757.   };};};};
  758.  
  759. for (i0=0; i0<KK; i0++) {
  760. for (i1=0; i1<KK; i1++) {
  761. for (i2=0; i2<KK; i2++) {
  762. for (i3=0; i3<KK; i3++) {
  763. for (i4=0; i4<KK; i4++) {
  764. for (i5=0; i5<KK; i5++) {
  765. for (i6=0; i6<KK; i6++) {
  766. for (i7=0; i7<KK; i7++) {
  767. for (i8=0; i8<KK; i8++) {
  768.   j0=ascrule[i0][i1][i2][i3][i4]-'0';
  769.   j1=ascrule[i1][i2][i3][i4][i5]-'0';
  770.   j2=ascrule[i2][i3][i4][i5][i6]-'0';
  771.   j3=ascrule[i3][i4][i5][i6][i7]-'0';
  772.   j4=ascrule[i4][i5][i6][i7][i8]-'0';
  773.   w=a[i0][i1][i2][i3][i4];
  774.   w*=a[i1][i2][i3][i4][i5];
  775.   w*=a[i2][i3][i4][i5][i6];
  776.   w*=a[i3][i4][i5][i6][i7];
  777.   w*=a[i4][i5][i6][i7][i8];
  778.   if (w!=0.0) w/=b[i1][i2][i3][i4]*b[i2][i3][i4][i5]*b[i3][i4][i5][i6]*b[i4][i5][i6][i7];
  779.   x[j0][j1][j2][j3][j4]+=w;
  780.   };};};};};};};};};
  781. }
  782.  
  783. /* iterate the 5-block parameters to find self-consistent values */
  784. /* ll - initial line    */
  785. /* mm - length of line    */
  786. /* nn - number of lines    */
  787. fivblfreq(ll,mm,nn) int ll, mm, nn; {
  788. int    ii, i0, i1, i2, i3, i4, l, m, n;
  789. double op[KK][KK][KK][KK][KK], np[KK][KK][KK][KK][KK];
  790. double b[KK], bb[KK][KK], d, e, f, s;
  791.  
  792. m=0;
  793. f=(double)mm;
  794. s=1.0/((double)(KK*KK*KK*KK*KK));
  795. n=(int)(f*s);
  796. videodot(ll,m++,3);
  797. for (i0=0; i0<KK; i0++) {
  798. for (i1=0; i1<KK; i1++) {
  799. for (i2=0; i2<KK; i2++) {
  800. for (i3=0; i3<KK; i3++) {
  801. for (i4=0; i4<KK; i4++) {
  802.   op[i0][i1][i2][i3][i4]=s;
  803.   for (l=0; l<n; l++) videodot(ll,m++,i4);
  804.   };};};};};
  805. videodot(ll,m++,3);
  806.  
  807. for (ii=1; ii<=nn; ii++) {
  808.   e=0.0; m=0;
  809.   fivbl(np,op);
  810.   videodot(ll+ii,m++,3);
  811.   for (i0=0; i0<KK; i0++) {
  812.   for (i1=0; i1<KK; i1++) {
  813.   for (i2=0; i2<KK; i2++) {
  814.   for (i3=0; i3<KK; i3++) {
  815.   for (i4=0; i4<KK; i4++) {
  816.     n=(int)(f*np[i0][i1][i2][i3][i4]);
  817.     if (n>0) for (l=0; l<n; l++) videodot(ll+ii,m++,i4);
  818.     d=op[i0][i1][i2][i3][i4]-np[i0][i1][i2][i3][i4];
  819.     e+=d<0.0?-d:d;
  820.     op[i0][i1][i2][i3][i4]=np[i0][i1][i2][i3][i4];
  821.     };};};};};
  822.   videodot(ll+ii,m++,3);
  823.   if (e<=0.0001) break;
  824.   if (kbdst()) {kbdin(); break;};
  825.   };
  826. for (i0=0; i0<KK; i0++) {
  827.   b[i0]=0.0;
  828.   for (i1=0; i1<KK; i1++) {
  829.   for (i2=0; i2<KK; i2++) {
  830.   for (i3=0; i3<KK; i3++) {
  831.   for (i4=0; i4<KK; i4++) {
  832.     b[i0]+=op[i0][i1][i2][i3][i4];
  833.     };};};}; };
  834. videocursor(0,BROW+7,0);
  835. printf("(5-block) "); 
  836. for (i0=0; i0<KK; i0++) printf("%2d:%5.3f ",i0,b[i0]);
  837.  
  838. for (i0=0; i0<KK; i0++) {
  839. for (i1=0; i1<KK; i1++) {
  840.   bb[i0][i1]=0.0;
  841.   for (i2=0; i2<KK; i2++) {
  842.   for (i3=0; i3<KK; i3++) {
  843.   for (i4=0; i4<KK; i4++) {
  844.     bb[i0][i1]+=op[i0][i1][i2][i3][i4];
  845.     };}; };};};
  846.  
  847. videocursor(0,BROW+8,0);
  848. for (i0=0; i0<KK; i0++) for (i1=0; i1<KK; i1++) 
  849.   printf("%1d%1d:%5.3f ",i0,i1,bb[i0][i1]);
  850. videodot(199-(int)(100.0*bb[1][1]),BORG+(int)(100.0*b[1]),2);
  851. }
  852.  
  853. /* evaluate the six-block probabilities after one generation */
  854. sixbl(x,a) double x[KK][KK][KK][KK][KK][KK], a[KK][KK][KK][KK][KK][KK]; {
  855. int    i0, i1, i2, i3, i4, i5, i6, i7, i8, i9;
  856. int    j0, j1, j2, j3, j4, j5;
  857. double w, b[KK][KK][KK][KK][KK];
  858.  
  859. for (j0=0; j0<KK; j0++) {
  860. for (j1=0; j1<KK; j1++) {
  861. for (j2=0; j2<KK; j2++) {
  862. for (j3=0; j3<KK; j3++) {
  863. for (j4=0; j4<KK; j4++) {
  864.   for (j5=0; j5<KK; j5++) x[j0][j1][j2][j3][j4][j5]=0.0;
  865.   b[j0][j1][j2][j3][j4]=0.0;
  866.   for (j5=0; j5<KK; j5++) b[j0][j1][j2][j3][j4]+=a[j0][j1][j2][j3][j4][j5];  
  867.   };};};};};
  868.  
  869. for (i0=0; i0<KK; i0++) {
  870. for (i1=0; i1<KK; i1++) {
  871. for (i2=0; i2<KK; i2++) {
  872. for (i3=0; i3<KK; i3++) {
  873. for (i4=0; i4<KK; i4++) {
  874. for (i5=0; i5<KK; i5++) {
  875. for (i6=0; i6<KK; i6++) {
  876. for (i7=0; i7<KK; i7++) {
  877. for (i8=0; i8<KK; i8++) {
  878. for (i9=0; i9<KK; i9++) {
  879.   j0=ascrule[i0][i1][i2][i3][i4]-'0';
  880.   j1=ascrule[i1][i2][i3][i4][i5]-'0';
  881.   j2=ascrule[i2][i3][i4][i5][i6]-'0';
  882.   j3=ascrule[i3][i4][i5][i6][i7]-'0';
  883.   j4=ascrule[i4][i5][i6][i7][i8]-'0';
  884.   j5=ascrule[i5][i6][i7][i8][i9]-'0';
  885.   w=a[i0][i1][i2][i3][i4][i5];
  886.   w*=a[i1][i2][i3][i4][i5][i6];
  887.   w*=a[i2][i3][i4][i5][i6][i7];
  888.   w*=a[i3][i4][i5][i6][i7][i8];
  889.   w*=a[i4][i5][i6][i7][i8][i9];
  890.   if (w!=0.0) w/=b[i1][i2][i3][i4][i5]*b[i2][i3][i4][i5][i6]*b[i3][i4][i5][i6][i7]*b[i4][i5][i6][i7][i8];
  891.   x[j0][j1][j2][j3][j4][j5]+=w;
  892.   };};};};};};};};};};
  893. }
  894.  
  895. /* iterate the 6-block parameters to find self-consistent values */
  896. /* ll - initial line    */
  897. /* mm - length of line    */
  898. /* nn - number of lines    */
  899. sixblfreq(ll,mm,nn) int ll, mm, nn; {
  900. int    ii, i0, i1, i2, i3, i4, i5, l, m, n;
  901. double op[KK][KK][KK][KK][KK][KK];
  902. double np[KK][KK][KK][KK][KK][KK];
  903. double b[KK], bb[KK][KK], d, e, f, s;
  904.  
  905. m=0;
  906. f=(double)mm;
  907. s=1.0/((double)(KK*KK*KK*KK*KK*KK));
  908. n=(int)(f*s);
  909. videodot(ll,m++,3);
  910. for (i0=0; i0<KK; i0++) {
  911. for (i1=0; i1<KK; i1++) {
  912. for (i2=0; i2<KK; i2++) {
  913. for (i3=0; i3<KK; i3++) {
  914. for (i4=0; i4<KK; i4++) {
  915. for (i5=0; i5<KK; i5++) {
  916.   op[i0][i1][i2][i3][i4][i5]=s;
  917.   for (l=0; l<n; l++) videodot(ll,m++,i5);
  918.   };};};};};};
  919. videodot(ll,m++,3);
  920.  
  921. for (ii=1; ii<=nn; ii++) {
  922.   e=0.0; m=0;
  923.   sixbl(np,op);
  924.   videodot(ll+ii,m++,3);
  925.   for (i0=0; i0<KK; i0++) {
  926.   for (i1=0; i1<KK; i1++) {
  927.   for (i2=0; i2<KK; i2++) {
  928.   for (i3=0; i3<KK; i3++) {
  929.   for (i4=0; i4<KK; i4++) {
  930.   for (i5=0; i5<KK; i5++) {
  931.     n=(int)(f*np[i0][i1][i2][i3][i4][i5]);
  932.     if (n>0) for (l=0; l<n; l++) videodot(ll+ii,m++,i5);
  933.     d=op[i0][i1][i2][i3][i4][i5]-np[i0][i1][i2][i3][i4][i5];
  934.     e+=d<0.0?-d:d;
  935.     op[i0][i1][i2][i3][i4][i5]=np[i0][i1][i2][i3][i4][i5];
  936.     };};};};};};
  937.   videodot(ll+ii,m++,3);
  938.   if (e<=0.0001) break;
  939.   if (kbdst()) {kbdin(); break;};
  940.   };
  941. for (i0=0; i0<KK; i0++) {
  942.   b[i0]=0.0;
  943.   for (i1=0; i1<KK; i1++) {
  944.   for (i2=0; i2<KK; i2++) {
  945.   for (i3=0; i3<KK; i3++) {
  946.   for (i4=0; i4<KK; i4++) {
  947.   for (i5=0; i5<KK; i5++) {
  948.     b[i0]+=op[i0][i1][i2][i3][i4][i5];
  949.     };};};};}; };
  950. videocursor(0,BROW+7,0);
  951. printf("(6-block) "); 
  952. for (i0=0; i0<KK; i0++) printf("%2d:%5.3f ",i0,b[i0]);
  953.  
  954. for (i0=0; i0<KK; i0++) {
  955. for (i1=0; i1<KK; i1++) {
  956.   bb[i0][i1]=0.0;
  957.   for (i2=0; i2<KK; i2++) {
  958.   for (i3=0; i3<KK; i3++) {
  959.   for (i4=0; i4<KK; i4++) {
  960.   for (i5=0; i5<KK; i5++) {
  961.     bb[i0][i1]+=op[i0][i1][i2][i3][i4][i5];
  962.     };}; };};};};
  963.  
  964. videocursor(0,BROW+8,0);
  965. for (i0=0; i0<KK; i0++) for (i1=0; i1<KK; i1++) 
  966.   printf("%1d%1d:%5.3f ",i0,i1,bb[i0][i1]);
  967. videodot(199-(int)(100.0*bb[1][1]),BORG+(int)(100.0*b[1]),2);
  968. }
  969.  
  970. /* end */
  971.